home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / Icon 8.1 / msm-1 / icont.sit / icon_g.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-19  |  9.8 KB  |  411 lines  |  [TEXT/MPS ]
  1. /*
  2.  * icong.c -- grammar for Icon Version 8.0.
  3.  *
  4.  * NOTE: Any modifications of this grammar should be
  5.  * propagated to any affected macro in gdefs.h.
  6.  */
  7. #include "::h:define.h"
  8.  
  9. /* primitive tokens */
  10.  
  11. %token    CSETLIT
  12.     EOFX
  13.     IDENT
  14.     INTLIT
  15.     REALLIT
  16.     STRINGLIT
  17.  
  18. /* reserved words */
  19.  
  20. %token    BREAK        /* break */
  21.     BY        /* by */
  22.     CASE        /* case */
  23.     CREATE        /* create */
  24.     DEFAULT        /* default */
  25.     DO        /* do */
  26.     ELSE        /* else */
  27.     END        /* end */
  28.     EVERY        /* every */
  29.     FAIL        /* fail */
  30.     GLOBAL        /* global */
  31.     IF        /* if */
  32.     INITIAL        /* initial */
  33.     INVOCABLE    /* invocable */
  34.     LINK        /* link */
  35.     LOCAL        /* link */
  36.     NEXT        /* next */
  37.     NOT        /* not */
  38.     OF        /* of */
  39.     PROCEDURE    /* procedure */
  40.     RECORD        /* record */
  41.     REPEAT        /* repeat */
  42.     RETURN        /* return */
  43.     STATIC        /* static */
  44.     SUSPEND        /* suspend */
  45.     THEN        /* then */
  46.     TO        /* to */
  47.     UNTIL        /* until */
  48.     WHILE        /* while */
  49.  
  50. /* operators */
  51.  
  52. %token    ASSIGN        /* := */
  53.     AT        /* @ */
  54.     AUGACT        /* @:= */
  55.     AUGAND        /* &:= */
  56.     AUGEQ        /* =:= */
  57.     AUGEQV        /* ===:= */
  58.     AUGGE        /* >=:= */
  59.     AUGGT        /* >:= */
  60.     AUGLE        /* <=:= */
  61.     AUGLT        /* <:= */
  62.     AUGNE        /* ~=:= */
  63.     AUGNEQV        /* ~===:= */
  64.     AUGSEQ        /* ==:= */
  65.     AUGSGE        /* >>=:= */
  66.     AUGSGT        /* >>:= */
  67.     AUGSLE        /* <<=:= */
  68.     AUGSLT        /* <<:= */
  69.     AUGSNE        /* ~==:= */
  70.     BACKSLASH    /* \ */
  71.     BANG        /* ! */
  72.     BAR        /* | */
  73.     CARET        /* ^ */
  74.     CARETASGN    /* ^:= */
  75.     COLON        /* : */
  76.     COMMA        /* , */
  77.     CONCAT        /* || */
  78.     CONCATASGN    /* ||:= */
  79.     CONJUNC        /* & */
  80.     DIFF        /* -- */
  81.     DIFFASGN    /* --:= */
  82.     DOT        /* . */
  83.     EQUIV        /* === */
  84.     INTER        /* ** */
  85.     INTERASGN    /* **:= */
  86.     LBRACE        /* { */
  87.     LBRACK        /* [ */
  88.     LCONCAT        /* ||| */
  89.     LCONCATASGN    /* |||:= */
  90.     LEXEQ        /* == */
  91.     LEXGE        /* >>= */
  92.     LEXGT        /* >> */
  93.     LEXLE        /* <<= */
  94.     LEXLT        /* << */
  95.     LEXNE        /* ~== */
  96.     LPAREN        /* ( */
  97.     MCOLON        /* -: */
  98.     MINUS        /* - */
  99.     MINUSASGN    /* -:= */
  100.     MOD        /* % */
  101.     MODASGN        /* %:= */
  102.     NOTEQUIV    /* ~=== */
  103.     NUMEQ        /* = */
  104.     NUMGE        /* >= */
  105.     NUMGT        /* > */
  106.     NUMLE        /* <= */
  107.     NUMLT        /* < */
  108.     NUMNE        /* ~= */
  109.     PCOLON        /* +: */
  110.     PLUS        /* + */
  111.     PLUSASGN    /* +:= */
  112.     QMARK        /* ? */
  113.     RBRACE        /* } */
  114.     RBRACK        /* ] */
  115.     REVASSIGN    /* <- */
  116.     REVSWAP        /* <-> */
  117.     RPAREN        /* ) */
  118.     SCANASGN    /* ?:= */
  119.     SEMICOL        /* ; */
  120.     SLASH        /* / */
  121.     SLASHASGN    /* /:= */
  122.     STAR        /* * */
  123.     STARASGN    /* *:= */
  124.     SWAP        /* :=: */
  125.     TILDE        /* ~ */
  126.     UNION        /* ++ */
  127.     UNIONASGN    /* ++:= */
  128. %{
  129. /*#include "../h/gsupport.h"*/
  130. /*#include "tproto.h"*/
  131. /*#include "trans.h"*/
  132. /*#include "tsym.h"*/
  133. /*#include "tree.h"*/
  134. /*#include "../h/keyword.h"*/
  135. /*#undef YYSTYPE*/
  136. /*#define YYSTYPE nodeptr*/
  137. /*#define YYMAXDEPTH 500*/
  138. #include "gdefs.h"
  139. %}
  140.  
  141. %%
  142.  
  143. program    : decls EOFX {Progend($1,$2);} ;
  144.  
  145. decls    : ;    
  146.     | decls decl ;
  147.  
  148. decl    : record {Recdcl($1);} ;
  149.     | proc {Procdcl($1);} ;
  150.     | global {Globdcl($1);} ;
  151.     | link {Linkdcl($1);} ;
  152.     | invocable ;
  153.  
  154. invocable : INVOCABLE invoclist ;
  155.  
  156. invoclist : invocop;
  157.       | invoclist COMMA invocop ;
  158.  
  159. invocop  : IDENT ;
  160.      | STRINGLIT ;
  161.      | STRINGLIT COLON INTLIT ;
  162.  
  163.  
  164. link    : LINK lnklist {Link($1, $2);} ;
  165.  
  166. lnklist    : lnkfile    ;
  167.     | lnklist COMMA lnkfile {Lnklist($1,$2,$3);} ;
  168.  
  169. lnkfile    : IDENT {Lnkfile1($1);} ;
  170.     | STRINGLIT {Lnkfile2($1);} ;
  171.  
  172. global    : GLOBAL {Global0($1);} idlist  {Global1($1, $2, $3);} ;
  173.  
  174. record    : RECORD {Record1($1);} IDENT LPAREN fldlist RPAREN {
  175.         Record2($1,$2,$3,$4,$5,$6);
  176.         } ;
  177.  
  178. fldlist    : {Arglist1();} ;
  179.     | idlist {Arglist2($1);} ;
  180.  
  181. proc    : prochead SEMICOL locals initial procbody END {
  182.         Proc1($1,$2,$3,$4,$5,$6);
  183.         } ;
  184.  
  185. prochead: PROCEDURE {Prochead1($1);} IDENT LPAREN arglist RPAREN {
  186.         Prochead2($1,$2,$3,$4,$5,$6);
  187.         } ;
  188.  
  189. arglist    : {Arglist1();} ;
  190.     | idlist {Arglist2($1);} ;
  191.     | idlist LBRACK RBRACK {Arglist3($1,$2,$3);} ;
  192.  
  193.  
  194. idlist    : IDENT {
  195.         Ident($1);
  196.         } ;
  197.     | idlist COMMA IDENT {
  198.         Idlist($1,$2,$3);
  199.         } ;
  200.  
  201. locals    : {Locals1();} ;
  202.     | locals retention idlist SEMICOL {Locals2($1,$2,$3,$4);} ;
  203.  
  204. retention: LOCAL {Local($1);} ;
  205.     | STATIC {Static($1);} ;
  206.  
  207. initial    : {Initial1();} ;
  208.     | INITIAL expr SEMICOL {Initial2($1,$2,$3);} ;
  209.  
  210. procbody: {Procbody1();} ;
  211.     | nexpr SEMICOL procbody {Procbody2($1,$2,$3);} ;
  212.  
  213. nexpr    : {Nexpr();} ;
  214.     | expr ;
  215.  
  216. expr    : expr1a    ;
  217.     | expr CONJUNC expr1a    {Bamper($1,$2,$3);} ;
  218.  
  219. expr1a    : expr1    ;
  220.     | expr1a QMARK expr1    {Bques($1,$2,$3);} ;
  221.  
  222. expr1    : expr2 ;
  223.     | expr2 SWAP expr1 {Bswap($1,$2,$3);} ;
  224.     | expr2 ASSIGN expr1 {Bassgn($1,$2,$3);} ;
  225.     | expr2 REVSWAP expr1 {Brswap($1,$2,$3);} ;
  226.     | expr2 REVASSIGN expr1 {Brassgn($1,$2,$3);} ;
  227.     | expr2 CONCATASGN expr1 {Baugcat($1,$2,$3);} ;
  228.     | expr2 LCONCATASGN expr1 {Bauglcat($1,$2,$3);} ;
  229.     | expr2 DIFFASGN expr1 {Bdiffa($1,$2,$3);} ;
  230.     | expr2 UNIONASGN expr1 {Buniona($1,$2,$3);} ;
  231.     | expr2 PLUSASGN expr1 {Bplusa($1,$2,$3);} ;
  232.     | expr2 MINUSASGN expr1 {Bminusa($1,$2,$3);} ;
  233.     | expr2 STARASGN expr1 {Bstara($1,$2,$3);} ;
  234.     | expr2 INTERASGN expr1 {Bintera($1,$2,$3);} ;
  235.     | expr2 SLASHASGN expr1 {Bslasha($1,$2,$3);} ;
  236.     | expr2 MODASGN expr1 {Bmoda($1,$2,$3);} ;
  237.     | expr2 CARETASGN expr1 {Bcareta($1,$2,$3);} ;
  238.     | expr2 AUGEQ expr1 {Baugeq($1,$2,$3);} ;
  239.     | expr2 AUGEQV expr1 {Baugeqv($1,$2,$3);} ;
  240.     | expr2 AUGGE expr1 {Baugge($1,$2,$3);} ;
  241.     | expr2 AUGGT expr1 {Bauggt($1,$2,$3);} ;
  242.     | expr2 AUGLE expr1 {Baugle($1,$2,$3);} ;
  243.     | expr2 AUGLT expr1 {Bauglt($1,$2,$3);} ;
  244.     | expr2 AUGNE expr1 {Baugne($1,$2,$3);} ;
  245.     | expr2 AUGNEQV expr1 {Baugneqv($1,$2,$3);} ;
  246.     | expr2 AUGSEQ expr1 {Baugseq($1,$2,$3);} ;
  247.     | expr2 AUGSGE expr1 {Baugsge($1,$2,$3);} ;
  248.     | expr2 AUGSGT expr1 {Baugsgt($1,$2,$3);} ;
  249.     | expr2 AUGSLE expr1 {Baugsle($1,$2,$3);} ;
  250.     | expr2 AUGSLT expr1 {Baugslt($1,$2,$3);} ;
  251.     | expr2 AUGSNE expr1 {Baugsne($1,$2,$3);} ;
  252.     | expr2 SCANASGN expr1 {Baugques($1,$2,$3);} ;
  253.     | expr2 AUGAND expr1 {Baugamper($1,$2,$3);} ;
  254.     | expr2 AUGACT expr1 {Baugact($1,$2,$3);} ;
  255.  
  256. expr2    : expr3 ;
  257.     | expr2 TO expr3 {To0($1,$2,$3);} ;
  258.     | expr2 TO expr3 BY expr3 {To1($1,$2,$3,$4,$5);} ;
  259.  
  260. expr3    : expr4 ;
  261.     | expr4 BAR expr3 {Alt($1,$2,$3);} ;
  262.  
  263. expr4    : expr5 ;
  264.     | expr4 LEXEQ expr5 {Bseq($1,$2,$3);} ;
  265.     | expr4 LEXGE expr5 {Bsge($1,$2,$3);} ;
  266.     | expr4 LEXGT expr5 {Bsgt($1,$2,$3);} ;
  267.     | expr4 LEXLE expr5 {Bsle($1,$2,$3);} ;
  268.     | expr4 LEXLT expr5 {Bslt($1,$2,$3);} ;
  269.     | expr4 LEXNE expr5 {Bsne($1,$2,$3);} ;
  270.     | expr4 NUMEQ expr5 {Beq($1,$2,$3);} ;
  271.     | expr4 NUMGE expr5 {Bge($1,$2,$3);} ;
  272.     | expr4 NUMGT expr5 {Bgt($1,$2,$3);} ;
  273.     | expr4 NUMLE expr5 {Ble($1,$2,$3);} ;
  274.     | expr4 NUMLT expr5 {Blt($1,$2,$3);} ;
  275.     | expr4 NUMNE expr5 {Bne($1,$2,$3);} ;
  276.     | expr4 EQUIV expr5 {Beqv($1,$2,$3);} ;
  277.     | expr4 NOTEQUIV expr5 {Bneqv($1,$2,$3);} ;
  278.  
  279. expr5    : expr6 ;
  280.     | expr5 CONCAT expr6 {Bcat($1,$2,$3);} ;
  281.     | expr5 LCONCAT expr6 {Blcat($1,$2,$3);} ;
  282.  
  283. expr6    : expr7 ;
  284.     | expr6 PLUS expr7 {Bplus($1,$2,$3);} ;
  285.     | expr6 DIFF expr7 {Bdiff($1,$2,$3);} ;
  286.     | expr6 UNION expr7 {Bunion($1,$2,$3);} ;
  287.     | expr6 MINUS expr7 {Bminus($1,$2,$3);} ;
  288.  
  289. expr7    : expr8 ;
  290.     | expr7 STAR expr8 {Bstar($1,$2,$3);} ;
  291.     | expr7 INTER expr8 {Binter($1,$2,$3);} ;
  292.     | expr7 SLASH expr8 {Bslash($1,$2,$3);} ;
  293.     | expr7 MOD expr8 {Bmod($1,$2,$3);} ;
  294.  
  295. expr8    : expr9 ;
  296.     | expr9 CARET expr8 {Bcaret($1,$2,$3);} ;
  297.  
  298. expr9    : expr10 ;
  299.     | expr9 BACKSLASH expr10 {Blim($1,$2,$3);} ;
  300.     | expr9 AT expr10 {Bact($1,$2,$3);};
  301.     | expr9 BANG expr10 {Apply($1,$2,$3);};
  302.  
  303. expr10    : expr11 ;
  304.     | AT expr10 {Uat($1,$2);} ;
  305.     | NOT expr10 {Unot($1,$2);} ;
  306.     | BAR expr10 {Ubar($1,$2);} ;
  307.     | CONCAT expr10 {Uconcat($1,$2);} ;
  308.     | LCONCAT expr10 {Ulconcat($1,$2);} ;
  309.     | DOT expr10 {Udot($1,$2);} ;
  310.     | BANG expr10 {Ubang($1,$2);} ;
  311.     | DIFF expr10 {Udiff($1,$2);} ;
  312.     | PLUS expr10 {Uplus($1,$2);} ;
  313.     | STAR expr10 {Ustar($1,$2);} ;
  314.     | SLASH expr10 {Uslash($1,$2);} ;
  315.     | CARET expr10 {Ucaret($1,$2);} ;
  316.     | INTER expr10 {Uinter($1,$2);} ;
  317.     | TILDE expr10 {Utilde($1,$2);} ;
  318.     | MINUS expr10 {Uminus($1,$2);} ;
  319.     | NUMEQ expr10 {Unumeq($1,$2);} ;
  320.     | NUMNE expr10 {Unumne($1,$2);} ;
  321.     | LEXEQ expr10 {Ulexeq($1,$2);} ;
  322.     | LEXNE expr10 {Ulexne($1,$2);} ;
  323.     | EQUIV expr10 {Uequiv($1,$2);} ;
  324.     | UNION expr10 {Uunion($1,$2);} ;
  325.     | QMARK expr10 {Uqmark($1,$2);} ;
  326.     | NOTEQUIV expr10 {Unotequiv($1,$2);} ;
  327.     | BACKSLASH expr10 {Ubackslash($1,$2);} ;
  328. expr11    : literal ;
  329.     | section ;
  330.     | return ;
  331.     | if ;
  332.     | case ;
  333.     | while ;
  334.     | until ;
  335.     | every ;
  336.     | repeat ;
  337.     | CREATE expr {Create($1,$2);} ;
  338.     | IDENT {Var($1);} ;
  339.     | NEXT {Next($1);} ;
  340.     | BREAK nexpr {Break($1,$2);} ;
  341.     | LPAREN exprlist RPAREN {Paren($1,$2,$3);} ;
  342.     | LBRACE compound RBRACE {Brace($1,$2,$3);} ;
  343.     | LBRACK exprlist RBRACK {Brack($1,$2,$3);} ;
  344.     | expr11 LBRACK exprlist RBRACK {Array($1,$2,$3,$4);} ;
  345.     | expr11 LBRACK nexpr RBRACK {Subscript($1,$2,$3,$4);} ;
  346.     | expr11 LBRACE    RBRACE {Pdco0($1,$2,$3);} ;
  347.     | expr11 LBRACE pdcolist RBRACE {Pdco1($1,$2,$3,$4);} ;
  348. #ifdef Xver
  349. xver(icon_g.1)
  350. #endif                    /* Xver */
  351.     | expr11 LPAREN exprlist RPAREN {Invoke($1,$2,$3,$4);} ;
  352.     | expr11 DOT IDENT {Field($1,$2,$3);} ;
  353.     | CONJUNC FAIL {Kfail($1,$2);} ;
  354.     | CONJUNC IDENT {Keyword($1,$2);} ;
  355.  
  356. while    : WHILE expr {While0($1,$2);} ;
  357.     | WHILE expr DO expr {While1($1,$2,$3,$4);} ;
  358.  
  359. until    : UNTIL expr {Until0($1,$2);} ;
  360.     | UNTIL expr DO expr {Until1($1,$2,$3,$4);} ;
  361.  
  362. every    : EVERY expr {Every0($1,$2);} ;
  363.     | EVERY expr DO expr {Every1($1,$2,$3,$4);} ;
  364.  
  365. repeat    : REPEAT expr {Repeat($1,$2);} ;
  366.  
  367. return    : FAIL {Fail($1);} ;
  368.     | RETURN nexpr {Return($1,$2);} ;
  369.     | SUSPEND nexpr {Suspend0($1,$2);} ;
  370.     | SUSPEND expr DO expr {Suspend1($1,$2,$3,$4);};
  371.  
  372. if    : IF expr THEN expr {If0($1,$2,$3,$4);} ;
  373.     | IF expr THEN expr ELSE expr {If1($1,$2,$3,$4,$5,$6);} ;
  374.  
  375. case    : CASE expr OF LBRACE caselist RBRACE {Case($1,$2,$3,$4,$5,$6);} ;
  376.  
  377. caselist: cclause ;
  378.     | caselist SEMICOL cclause {Caselist($1,$2,$3);} ;
  379.  
  380. cclause    : DEFAULT COLON expr {Cclause0($1,$2,$3);} ;
  381.     | expr COLON expr {Cclause1($1,$2,$3);} ;
  382.  
  383. exprlist: nexpr
  384.     | exprlist COMMA nexpr {Exprlist($1,$2,$3);} ;
  385.  
  386. pdcolist: nexpr {
  387.         Pdcolist0($1);
  388.         } ;
  389.     | pdcolist COMMA nexpr {
  390.         Pdcolist1($1,$2,$3);
  391.         } ;
  392.  
  393. literal    : INTLIT {Iliter($1);} ;
  394.     | REALLIT {Rliter($1);} ;
  395.     | STRINGLIT {Sliter($1);} ;
  396.     | CSETLIT {Cliter($1);} ;
  397.  
  398. section    : expr11 LBRACK expr sectop expr RBRACK {Section($1,$2,$3,$4,$5,$6);} ;
  399.  
  400. sectop    : COLON {Colon($1);} ;
  401.     | PCOLON {Pcolon($1);} ;
  402.     | MCOLON {Mcolon($1);} ;
  403.  
  404. compound: nexpr ;
  405.     | nexpr SEMICOL compound {Compound($1,$2,$3);} ;
  406.  
  407. program    : error decls EOFX ;
  408. proc    : prochead error procbody END ;
  409. expr    : error ;
  410. %%
  411.